home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / termv4.6 / extras / source / term-source.lha / UploadQueue.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  30.6 KB  |  1,503 lines
  1. /*
  2. **    UploadQueue.c
  3. **
  4. **    Upload queue user interface.
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #ifndef _GLOBAL_H
  11. #include "Global.h"
  12. #endif
  13.  
  14. enum    {    GAD_LIST=1000,GAD_NAME,
  15.         GAD_ADD,GAD_REMOVE,GAD_CLEAR,GAD_HIDE,
  16.         GAD_ADD_FILES
  17.     };
  18.  
  19. enum    {    APP_ICON=1,APP_WINDOW=2 };
  20.  
  21. enum    {    TRANSFERMSG_GET_LIST=1,TRANSFERMSG_CHECK_LIST,
  22.         TRANSFERMSG_UPLOAD,TRANSFERMSG_TOGGLE_ICON
  23.     };
  24.  
  25. STATIC struct List    *TransferList;
  26. STATIC struct Node    *TransferNode;
  27. STATIC LONG         TransferOffset,
  28.              TransferCount,
  29.              TransferSignal;
  30. STATIC struct MsgQueue    *TransferQueue;
  31.  
  32.     /* QueuePanel(struct Window *Window):
  33.      *
  34.      *    Create the user interface for the queue panel.
  35.      */
  36.  
  37. STATIC LayoutHandle *
  38. QueuePanel(struct Window *Window)
  39. {
  40.     LayoutHandle *Handle;
  41.  
  42.     TransferNode    = NULL;
  43.     TransferOffset    = -1;
  44.     TransferCount    = GetListSize(TransferList);
  45.  
  46.     if(Handle = LT_CreateHandleTags(Window ? Window -> WScreen : NULL,
  47.         LH_LocaleHook,    &LocaleHook,
  48.     TAG_DONE))
  49.     {
  50.         LT_New(Handle,
  51.             LA_Type,    VERTICAL_KIND,
  52.         TAG_DONE);
  53.         {
  54.             LT_New(Handle,
  55.                 LA_Type,    VERTICAL_KIND,
  56.             TAG_DONE);
  57.             {
  58.                 LT_New(Handle,
  59.                     LA_Type,    LISTVIEW_KIND,
  60.                     LA_LabelID,    MSG_UPLOADQUEUE_FILES_TO_UPLOAD_TXT,
  61.                     LA_LabelPlace,    PLACE_ABOVE,
  62.                     LA_Chars,    30,
  63.                     LA_Lines,    10,
  64.                     LA_ID,        GAD_LIST,
  65.                     LALV_CursorKey,    TRUE,
  66.                     LALV_MaxGrowY,    20,
  67.                     LALV_MaxGrowX,    50,
  68.                     LALV_ResizeX,    TRUE,
  69.                     LALV_ResizeY,    TRUE,
  70.                     GTLV_Labels,    TransferList,
  71.  
  72.                     Kick30 ? LALV_Link : TAG_IGNORE,NIL_LINK,
  73.                 TAG_DONE);
  74.  
  75.                 LT_New(Handle,
  76.                     LA_Type,    STRING_KIND,
  77.                     LA_ID,        GAD_NAME,
  78.                     GTST_MaxChars,    255,
  79.                     LAST_Picker,    TRUE,
  80.                 TAG_DONE);
  81.  
  82.                 LT_EndGroup(Handle);
  83.             }
  84.  
  85.             LT_New(Handle,
  86.                 LA_Type,    HORIZONTAL_KIND,
  87.                 LA_LabelID,    MSG_V36_0043,
  88.                 LA_SameSize,    TRUE,
  89.             TAG_DONE);
  90.             {
  91.                 LT_New(Handle,
  92.                     LA_Type,    BUTTON_KIND,
  93.                     LA_LabelID,    MSG_ADD_SEVERAL_FILES_TXT,
  94.                     LA_ID,        GAD_ADD_FILES,
  95.                 TAG_DONE);
  96.  
  97.                 LT_New(Handle,
  98.                     LA_Type,    BUTTON_KIND,
  99.                     LA_LabelID,    MSG_UPLOADQUEUE_ADD_TXT,
  100.                     LA_ID,        GAD_ADD,
  101.                 TAG_DONE);
  102.  
  103.                 LT_New(Handle,
  104.                     LA_Type,    BUTTON_KIND,
  105.                     LA_LabelID,    MSG_UPLOADQUEUE_REMOVE_TXT,
  106.                     LA_ID,        GAD_REMOVE,
  107.                     GA_Disabled,    TRUE,
  108.                 TAG_DONE);
  109.  
  110.                 LT_New(Handle,
  111.                     LA_Type,    BUTTON_KIND,
  112.                     LA_LabelID,    MSG_UPLOADQUEUE_CLEAR_TXT,
  113.                     LA_ID,        GAD_CLEAR,
  114.                     GA_Disabled,    !TransferCount,
  115.                 TAG_DONE);
  116.  
  117.                 LT_EndGroup(Handle);
  118.             }
  119.  
  120.             LT_New(Handle,
  121.                 LA_Type,    VERTICAL_KIND,
  122.             TAG_DONE);
  123.             {
  124.                 LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);
  125.  
  126.                 LT_EndGroup(Handle);
  127.             }
  128.  
  129.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  130.                 LAGR_SameSize,    TRUE,
  131.                 LAGR_Spread,    TRUE,
  132.             TAG_DONE);
  133.             {
  134.                 LT_New(Handle,
  135.                     LA_Type,    BUTTON_KIND,
  136.                     LA_LabelID,    MSG_UPLOADQUEUE_BINARY_UPLOAD_TXT,
  137.                     LA_ID,        UPLOAD_BINARY,
  138.                     LABT_ExtraFat,    TRUE,
  139.                     LABT_ReturnKey,    TRUE,
  140.                     GA_Disabled,    !TransferCount,
  141.                 TAG_DONE);
  142.  
  143.                 LT_New(Handle,
  144.                     LA_Type,    BUTTON_KIND,
  145.                     LA_LabelID,    MSG_UPLOADQUEUE_TEXT_UPLOAD_TXT,
  146.                     LA_ID,        UPLOAD_TEXT,
  147.                     GA_Disabled,    !TransferCount,
  148.                 TAG_DONE);
  149.  
  150.                 LT_New(Handle,
  151.                     LA_Type,    BUTTON_KIND,
  152.                     LA_LabelID,    MSG_UPLOADQUEUE_HIDE_TXT,
  153.                     LA_ID,        GAD_HIDE,
  154.                     LABT_EscKey,    TRUE,
  155.                 TAG_DONE);
  156.  
  157.                 LT_EndGroup(Handle);
  158.             }
  159.  
  160.             LT_EndGroup(Handle);
  161.         }
  162.  
  163.         if(LT_Build(Handle,
  164.             LAWN_TitleID,        MSG_UPLOADQUEUE_FILE_UPLOAD_LIST_TXT,
  165.             LAWN_IDCMP,        IDCMP_CLOSEWINDOW,
  166.             LAWN_BelowMouse,    TRUE,
  167.             WA_DepthGadget,        TRUE,
  168.             WA_CloseGadget,        TRUE,
  169.             WA_DragBar,        TRUE,
  170.             WA_RMBTrap,        TRUE,
  171.             WA_Activate,        TRUE,
  172.             WA_SimpleRefresh,    TRUE,
  173.         TAG_DONE))
  174.         {
  175.             GuideContext(CONTEXT_UPLOAD_QUEUE);
  176.  
  177.             return(Handle);
  178.         }
  179.  
  180.         LT_DeleteHandle(Handle);
  181.     }
  182.  
  183.     return(NULL);
  184. }
  185.  
  186.     /* HandleQueueWindow(LayoutHandle *Handle):
  187.      *
  188.      *    Process queue panel messages.
  189.      */
  190.  
  191. STATIC LONG
  192. HandleQueueWindow(LayoutHandle *Handle)
  193. {
  194.     struct IntuiMessage    *Message;
  195.     ULONG             MsgClass;
  196.     UWORD             MsgCode;
  197.     struct Gadget        *MsgGadget;
  198.  
  199.     struct Node        *Node;
  200.  
  201.     struct Window        *Window = Handle -> Window;
  202.     LONG             Result = 0;
  203.  
  204.     UBYTE              DummyBuffer[MAX_FILENAME_LENGTH],
  205.                 *DummyChar;
  206.     struct FileRequester    *FileRequest;
  207.     struct TagItem         DimensionTags[5];
  208.  
  209.     while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  210.     {
  211.         MsgClass    = Message -> Class;
  212.         MsgCode        = Message -> Code;
  213.         MsgGadget    = (struct Gadget *)Message -> IAddress;
  214.  
  215.         LT_ReplyIMsg(Message);
  216.  
  217.         if(MsgClass == IDCMP_CLOSEWINDOW)
  218.             Result = GAD_HIDE;
  219.  
  220.         if(MsgClass == IDCMP_IDCMPUPDATE && MsgGadget -> GadgetID == GAD_NAME)
  221.         {
  222.             SplitFileName(LT_GetString(Handle,GAD_NAME),&DummyChar,DummyBuffer);
  223.  
  224.             if(FileRequest = GetFile(Window,LocaleString(MSG_UPLOADQUEUE_SELECT_FILE_TXT),DummyBuffer,DummyChar,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),FALSE))
  225.             {
  226.                 LT_SetAttributes(Handle,GAD_NAME,
  227.                     GTST_String,    DummyBuffer,
  228.                 TAG_DONE);
  229.             }
  230.  
  231.             LT_Activate(Handle,GAD_NAME);
  232.         }
  233.  
  234.         if(MsgClass == IDCMP_GADGETUP)
  235.         {
  236.             switch(MsgGadget -> GadgetID)
  237.             {
  238.                 case GAD_ADD_FILES:
  239.  
  240.                     LT_LockWindow(Window);
  241.  
  242.                     if(!GetCurrentDirName(DummyBuffer,MAX_FILENAME_LENGTH))
  243.                         DummyBuffer[0] = 0;
  244.  
  245.                     if(FileRequest = AllocAslRequestTags(ASL_FileRequest,
  246.                         ASLFR_Window,        Window,
  247.                         ASLFR_TitleText,    LocaleString(MSG_ADD_FILES_TITLE_TXT),
  248.                         ASLFR_Flags1,        FILF_MULTISELECT | FILF_NEWIDCMP,
  249.                         ASLFR_PositiveText,    LocaleString(MSG_ADD_GAD),
  250.                         ASLFR_NegativeText,    LocaleString(MSG_DONE_GAD),
  251.                         ASLFR_InitialDrawer,    DummyBuffer,
  252.                         ASLFR_TextAttr,        &UserFont,
  253.                         ASLFR_PrivateIDCMP,    TRUE,
  254.                     TAG_MORE,GetDimensionTags(Window,DimensionTags)))
  255.                     {
  256.                         LONG i;
  257.  
  258.                         LT_SetAttributes(Handle,GAD_LIST,
  259.                             GTLV_Labels,    ~0,
  260.                         TAG_DONE);
  261.  
  262.                         while(AslRequest(FileRequest,NULL))
  263.                         {
  264.                             for(i = 0 ; i < FileRequest -> fr_NumArgs ; i++)
  265.                             {
  266.                                 if(FileRequest -> fr_ArgList[i] . wa_Lock)
  267.                                 {
  268.                                     if(!NameFromLock(FileRequest -> fr_ArgList[i] . wa_Lock,DummyBuffer,MAX_FILENAME_LENGTH))
  269.                                         DummyBuffer[0] = 0;
  270.                                 }
  271.                                 else
  272.                                     strcpy(DummyBuffer,FileRequest -> fr_Drawer);
  273.  
  274.                                 if(FileRequest -> fr_ArgList[i] . wa_Name)
  275.                                 {
  276.                                     if(!AddPart(DummyBuffer,FileRequest -> fr_ArgList[i] . wa_Name,MAX_FILENAME_LENGTH))
  277.                                         DummyBuffer[0] = 0;
  278.                                 }
  279.  
  280.                                 if(DummyBuffer[0])
  281.                                 {
  282.                                     if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  283.                                     {
  284.                                         Node -> ln_Name = (STRPTR)(Node + 1);
  285.  
  286.                                         strcpy(Node -> ln_Name,DummyBuffer);
  287.  
  288.                                         AddTail(TransferList,Node);
  289.  
  290.                                         TransferNode = Node;
  291.                                         TransferOffset = TransferCount++;
  292.                                     }
  293.                                 }
  294.                             }
  295.  
  296.                             LT_SetAttributes(Handle,GAD_LIST,
  297.                                 GTLV_Labels,    TransferList,
  298.                                 GTLV_Selected,    TransferOffset,
  299.                             TAG_DONE);
  300.                         }
  301.  
  302.                         LT_SetAttributes(Handle,GAD_LIST,
  303.                             GTLV_Labels,    TransferList,
  304.                             GTLV_Selected,    TransferOffset,
  305.                         TAG_DONE);
  306.  
  307.                         if(TransferCount)
  308.                         {
  309.                             LT_SetAttributes(Handle,GAD_NAME,
  310.                                 GTST_String,    "",
  311.                             TAG_DONE);
  312.  
  313.                             LT_SetAttributes(Handle,GAD_REMOVE,
  314.                                 GA_Disabled,    FALSE,
  315.                             TAG_DONE);
  316.  
  317.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  318.                                 GA_Disabled,    FALSE,
  319.                             TAG_DONE);
  320.  
  321.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  322.                                 GA_Disabled,    FALSE,
  323.                             TAG_DONE);
  324.  
  325.                             LT_SetAttributes(Handle,GAD_CLEAR,
  326.                                 GA_Disabled,    FALSE,
  327.                             TAG_DONE);
  328.                         }
  329.  
  330.                         PutDimensionTags(Window,FileRequest -> fr_LeftEdge,FileRequest -> fr_TopEdge,FileRequest -> fr_Width,FileRequest -> fr_Height);
  331.  
  332.                         FreeAslRequest(FileRequest);
  333.                     }
  334.  
  335.                     LT_UnlockWindow(Window);
  336.                     break;
  337.  
  338.                 case GAD_ADD:
  339.  
  340.                     if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  341.                     {
  342.                         Node -> ln_Name = (STRPTR)(Node + 1);
  343.  
  344.                         Node -> ln_Name[0] = 0;
  345.  
  346.                         LT_SetAttributes(Handle,GAD_LIST,
  347.                             GTLV_Labels,    ~0,
  348.                         TAG_DONE);
  349.  
  350.                         AddTail(TransferList,Node);
  351.  
  352.                         LT_SetAttributes(Handle,GAD_LIST,
  353.                             GTLV_Labels,    TransferList,
  354.                             GTLV_Selected,    TransferOffset = TransferCount++,
  355.                         TAG_DONE);
  356.  
  357.                         LT_SetAttributes(Handle,GAD_NAME,
  358.                             GTST_String,    "",
  359.                         TAG_DONE);
  360.  
  361.                         LT_SetAttributes(Handle,GAD_REMOVE,
  362.                             GA_Disabled,    FALSE,
  363.                         TAG_DONE);
  364.  
  365.                         LT_SetAttributes(Handle,UPLOAD_BINARY,
  366.                             GA_Disabled,    FALSE,
  367.                         TAG_DONE);
  368.  
  369.                         LT_SetAttributes(Handle,UPLOAD_TEXT,
  370.                             GA_Disabled,    FALSE,
  371.                         TAG_DONE);
  372.  
  373.                         LT_SetAttributes(Handle,GAD_CLEAR,
  374.                             GA_Disabled,    FALSE,
  375.                         TAG_DONE);
  376.  
  377.                         TransferNode = Node;
  378.  
  379.                         LT_Activate(Handle,GAD_NAME);
  380.                     }
  381.                     else
  382.                         DisplayBeep(Window -> WScreen);
  383.  
  384.                     break;
  385.  
  386.                 case GAD_REMOVE:
  387.  
  388.                     if(TransferNode)
  389.                     {
  390.                         LT_SetAttributes(Handle,GAD_LIST,
  391.                             GTLV_Labels,    ~0,
  392.                         TAG_DONE);
  393.  
  394.                         if(--TransferCount)
  395.                         {
  396.                             if(TransferNode -> ln_Succ -> ln_Succ)
  397.                                 Node = TransferNode -> ln_Succ;
  398.                             else
  399.                             {
  400.                                 if(TransferNode -> ln_Pred -> ln_Pred)
  401.                                 {
  402.                                     Node = TransferNode -> ln_Pred;
  403.  
  404.                                     TransferOffset--;
  405.                                 }
  406.                                 else
  407.                                 {
  408.                                     TransferOffset = -1;
  409.  
  410.                                     Node = NULL;
  411.                                 }
  412.                             }
  413.                         }
  414.                         else
  415.                         {
  416.                             TransferOffset = -1;
  417.  
  418.                             Node = NULL;
  419.                         }
  420.  
  421.                         Remove(TransferNode);
  422.  
  423.                         FreeVecPooled(TransferNode);
  424.  
  425.                         TransferNode = Node;
  426.  
  427.                         LT_SetAttributes(Handle,GAD_LIST,
  428.                             GTLV_Labels,    TransferList,
  429.                             GTLV_Selected,    TransferOffset,
  430.                         TAG_DONE);
  431.  
  432.                         if(!TransferCount)
  433.                         {
  434.                             LT_SetAttributes(Handle,GAD_REMOVE,
  435.                                 GA_Disabled,    TRUE,
  436.                             TAG_DONE);
  437.  
  438.                             LT_SetAttributes(Handle,GAD_NAME,
  439.                                 GTST_String,    "",
  440.                             TAG_DONE);
  441.  
  442.                             LT_SetAttributes(Handle,GAD_CLEAR,
  443.                                 GA_Disabled,    TRUE,
  444.                             TAG_DONE);
  445.  
  446.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  447.                                 GA_Disabled,    TRUE,
  448.                             TAG_DONE);
  449.  
  450.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  451.                                 GA_Disabled,    TRUE,
  452.                             TAG_DONE);
  453.                         }
  454.                         else
  455.                         {
  456.                             LT_SetAttributes(Handle,GAD_NAME,
  457.                                 GTST_String,    TransferNode -> ln_Name,
  458.                             TAG_DONE);
  459.                         }
  460.                     }
  461.  
  462.                     break;
  463.  
  464.                 case GAD_LIST:
  465.  
  466.                     if(TransferNode = (struct Node *)GetListNode(MsgCode,TransferList))
  467.                     {
  468.                         TransferOffset = MsgCode;
  469.  
  470.                         LT_SetAttributes(Handle,GAD_NAME,
  471.                             GTST_String,    TransferNode -> ln_Name,
  472.                         TAG_DONE);
  473.  
  474.                         LT_SetAttributes(Handle,GAD_REMOVE,
  475.                             GA_Disabled,    FALSE,
  476.                         TAG_DONE);
  477.                     }
  478.  
  479.                     break;
  480.  
  481.                 case GAD_NAME:
  482.  
  483.                     if(TransferNode)
  484.                     {
  485.                         LT_SetAttributes(Handle,GAD_LIST,
  486.                             GTLV_Labels,    ~0,
  487.                         TAG_DONE);
  488.  
  489.                         strcpy(TransferNode -> ln_Name,LT_GetString(Handle,GAD_NAME));
  490.  
  491.                         LT_SetAttributes(Handle,GAD_LIST,
  492.                             GTLV_Labels,    TransferList,
  493.                             GTLV_Selected,    ~0,
  494.                         TAG_DONE);
  495.                     }
  496.                     else
  497.                     {
  498.                         if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  499.                         {
  500.                             Node -> ln_Name = (STRPTR)(Node + 1);
  501.  
  502.                             strcpy(Node -> ln_Name,LT_GetString(Handle,GAD_NAME));
  503.  
  504.                             LT_SetAttributes(Handle,GAD_LIST,
  505.                                 GTLV_Labels,    ~0,
  506.                             TAG_DONE);
  507.  
  508.                             AddTail(TransferList,Node);
  509.  
  510.                             TransferCount++;
  511.  
  512.                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  513.                                 GA_Disabled,    FALSE,
  514.                             TAG_DONE);
  515.  
  516.                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  517.                                 GA_Disabled,    FALSE,
  518.                             TAG_DONE);
  519.  
  520.                             LT_SetAttributes(Handle,GAD_CLEAR,
  521.                                 GA_Disabled,    FALSE,
  522.                             TAG_DONE);
  523.  
  524.                             LT_SetAttributes(Handle,GAD_LIST,
  525.                                 GTLV_Labels,        TransferList,
  526.                                 GTLV_Selected,        ~0,
  527.                                 GTLV_MakeVisible,    TransferCount - 1,
  528.                             TAG_DONE);
  529.                         }
  530.                     }
  531.  
  532.                     LT_SetAttributes(Handle,GAD_REMOVE,
  533.                         GA_Disabled,    TRUE,
  534.                     TAG_DONE);
  535.  
  536.                     LT_SetAttributes(Handle,GAD_NAME,
  537.                         GTST_String,    "",
  538.                     TAG_DONE);
  539.  
  540.                     TransferNode    = NULL;
  541.                     TransferOffset    = -1;
  542.  
  543.                     break;
  544.  
  545.                 case GAD_CLEAR:
  546.  
  547.                     LT_SetAttributes(Handle,GAD_LIST,
  548.                         GTLV_Labels,    ~0,
  549.                     TAG_DONE);
  550.  
  551.                     TransferCount    = 0;
  552.                     TransferOffset    = -1;
  553.                     TransferNode    = NULL;
  554.  
  555.                     FreeList(TransferList);
  556.  
  557.                     LT_SetAttributes(Handle,GAD_REMOVE,
  558.                         GA_Disabled,    TRUE,
  559.                     TAG_DONE);
  560.  
  561.                     LT_SetAttributes(Handle,GAD_NAME,
  562.                         GTST_String,    "",
  563.                     TAG_DONE);
  564.  
  565.                     LT_SetAttributes(Handle,GAD_CLEAR,
  566.                         GA_Disabled,    TRUE,
  567.                     TAG_DONE);
  568.  
  569.                     LT_SetAttributes(Handle,UPLOAD_BINARY,
  570.                         GA_Disabled,    TRUE,
  571.                     TAG_DONE);
  572.  
  573.                     LT_SetAttributes(Handle,UPLOAD_TEXT,
  574.                         GA_Disabled,    TRUE,
  575.                     TAG_DONE);
  576.  
  577.                     LT_SetAttributes(Handle,GAD_LIST,
  578.                         GTLV_Labels,    TransferList,
  579.                         GTLV_Selected,    ~0,
  580.                     TAG_DONE);
  581.  
  582.                     break;
  583.  
  584.                 case UPLOAD_BINARY:
  585.                 case UPLOAD_TEXT:
  586.                 case GAD_HIDE:
  587.  
  588.                     Result = MsgGadget -> GadgetID;
  589.                     break;
  590.             }
  591.         }
  592.     }
  593.  
  594.     return(Result);
  595. }
  596.  
  597.     /* QueueClientDestructor(struct DataMsg *Item):
  598.      *
  599.      *    Local msgitem destructor.
  600.      */
  601.  
  602. STATIC VOID __stdargs
  603. QueueClientDestructor(struct DataMsg *Item)
  604. {
  605.     Signal(TransferProcess,1L << TransferSignal);
  606. }
  607.  
  608.     /* QueueEntry(VOID):
  609.      *
  610.      *    The entry point for the queue process.
  611.      */
  612.  
  613. STATIC VOID __saveds
  614. QueueEntry(VOID)
  615. {
  616.     if(TransferList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  617.     {
  618.         if(TransferQueue = CreateMsgQueue(NULL,0))
  619.         {
  620.             struct MsgPort        *AppPort;
  621.             struct AppIcon        *AppIcon;
  622.             struct AppWindow    *AppWindow;
  623.             APTR             OldPtr;
  624.  
  625.             NewList(TransferList);
  626.  
  627.             TransferNode    = NULL;
  628.             TransferOffset    = -1;
  629.  
  630.             if(AppPort = CreateMsgPort())
  631.             {
  632.                 if((TransferSignal = AllocSignal(-1)) != -1)
  633.                 {
  634.                     ULONG             Signals;
  635.                     BOOL             Done = FALSE;
  636.                     LayoutHandle        *Handle;
  637.                     struct Window        *LocalWindow;
  638.                     ULONG             WindowMask,
  639.                                  TransferMask,
  640.                                  ClientMask;
  641.                     struct AppMessage    *AppMessage;
  642.                     struct DiskObject    *LoadedIcon = NULL;
  643.  
  644.                     if(WorkbenchBase && !Config -> TransferConfig -> HideUploadIcon)
  645.                     {
  646.                         if(IconBase)
  647.                         {
  648.                             UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  649.  
  650.                             strcpy(LocalBuffer,Config -> PathConfig -> DefaultStorage);
  651.  
  652.                             if(AddPart(LocalBuffer,"term_DropIcon",MAX_FILENAME_LENGTH))
  653.                                 LoadedIcon = GetDiskObject(LocalBuffer);
  654.  
  655.                             if(!LoadedIcon)
  656.                                 LoadedIcon = GetDiskObject("PROGDIR:term_DropIcon");
  657.                         }
  658.  
  659.                         AppIcon = AddAppIconA(APP_ICON,NULL,LocaleString(MSG_UPLOADQUEUE_TERM_UPLOAD_LIST_TXT),AppPort,NULL,LoadedIcon ? LoadedIcon : &DropIcon,NULL);
  660.                     }
  661.                     else
  662.                         AppIcon = NULL;
  663.  
  664.                     AppWindow    = NULL;
  665.                     WindowMask    = NULL;
  666.                     Handle        = NULL;
  667.                     LocalWindow    = NULL;
  668.                     TransferMask    = TransferQueue -> SigMask;
  669.                     ClientMask    = (1L << TransferSignal);
  670.  
  671.                     TransferProcess = (struct Process *)FindTask(NULL);
  672.  
  673.                     OldPtr = TransferProcess -> pr_WindowPtr;
  674.  
  675.                     Signal(ThisProcess,SIG_HANDSHAKE);
  676.  
  677.                     do
  678.                     {
  679.                         Signals = Wait(SIG_KILL | SIG_SHOW | SIG_HIDE | SIG_GOAWAY | WindowMask | TransferMask | PORTMASK(AppPort));
  680.  
  681.                         if(Signals & TransferMask)
  682.                         {
  683.                             struct DataMsg *Item;
  684.  
  685.                             while(Item = GetMsgItem(TransferQueue))
  686.                             {
  687.                                 switch(Item -> Type)
  688.                                 {
  689.                                     case TRANSFERMSG_GET_LIST:
  690.  
  691.                                         Item -> Data = NULL;
  692.  
  693.                                         if(TransferList -> lh_Head -> ln_Succ)
  694.                                         {
  695.                                             struct List *List;
  696.  
  697.                                             if(Handle)
  698.                                             {
  699.                                                 LT_SetAttributes(Handle,GAD_LIST,
  700.                                                     GTLV_Labels,    ~0,
  701.                                                 TAG_DONE);
  702.                                             }
  703.  
  704.                                             if(List = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  705.                                             {
  706.                                                 struct Node *Node,*Next;
  707.  
  708.                                                 NewList(List);
  709.  
  710.                                                 for(Node = TransferList -> lh_Head ; Next = Node -> ln_Succ ; Node = Next)
  711.                                                 {
  712.                                                     Remove(Node);
  713.  
  714.                                                     AddTail(List,Node);
  715.                                                 }
  716.  
  717.                                                 Item -> Data = (UBYTE *)List;
  718.                                             }
  719.  
  720.                                             if(Handle)
  721.                                             {
  722.                                                 TransferCount = GetListSize(TransferList);
  723.  
  724.                                                 TransferOffset    = -1;
  725.                                                 TransferNode    = NULL;
  726.  
  727.                                                 LT_SetAttributes(Handle,GAD_REMOVE,
  728.                                                     GA_Disabled,    TRUE,
  729.                                                 TAG_DONE);
  730.  
  731.                                                 LT_SetAttributes(Handle,GAD_NAME,
  732.                                                     GTST_String,    "",
  733.                                                 TAG_DONE);
  734.  
  735.                                                 LT_SetAttributes(Handle,GAD_CLEAR,
  736.                                                     GA_Disabled,    !TransferCount,
  737.                                                 TAG_DONE);
  738.  
  739.                                                 LT_SetAttributes(Handle,UPLOAD_BINARY,
  740.                                                     GA_Disabled,    !TransferCount,
  741.                                                 TAG_DONE);
  742.  
  743.                                                 LT_SetAttributes(Handle,UPLOAD_TEXT,
  744.                                                     GA_Disabled,    !TransferCount,
  745.                                                 TAG_DONE);
  746.  
  747.                                                 LT_SetAttributes(Handle,GAD_LIST,
  748.                                                     GTLV_Labels,    TransferList,
  749.                                                 TAG_DONE);
  750.                                             }
  751.                                         }
  752.  
  753.                                         break;
  754.  
  755.                                         // Check to see if there is anything in the list?
  756.  
  757.                                     case TRANSFERMSG_CHECK_LIST:
  758.  
  759.                                         if(TransferList -> lh_Head -> ln_Succ)
  760.                                             Item -> Size = TRUE;
  761.                                         else
  762.                                             Item -> Size = FALSE;
  763.  
  764.                                         break;
  765.  
  766.                                         // Start a file tansfer?
  767.  
  768.                                     case TRANSFERMSG_UPLOAD:
  769.                                     {
  770.                                         UBYTE        Type = Item -> Size;
  771.                                         struct DataMsg    Msg;
  772.  
  773.                                         DeleteMsgItem(Item);
  774.  
  775.                                         Item = NULL;
  776.  
  777.                                         InitMsgItem(&Msg,QueueClientDestructor);
  778.  
  779.                                         Msg . Type = DATAMSGTYPE_UPLOAD;
  780.                                         Msg . Data = (UBYTE *)TransferList;
  781.                                         Msg . Size = Type;
  782.  
  783.                                         if(Handle)
  784.                                         {
  785.                                             LT_SetAttributes(Handle,GAD_LIST,
  786.                                                 GTLV_Labels,    ~0,
  787.                                             TAG_DONE);
  788.  
  789.                                             LT_LockWindow(LocalWindow);
  790.                                         }
  791.  
  792.                                         Forbid();
  793.  
  794.                                         ClrSignal(ClientMask);
  795.  
  796.                                         PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
  797.  
  798.                                         Wait(ClientMask);
  799.  
  800.                                         Permit();
  801.  
  802.                                         if(Handle)
  803.                                         {
  804.                                             TransferCount = GetListSize(TransferList);
  805.  
  806.                                             TransferOffset    = -1;
  807.                                             TransferNode    = NULL;
  808.  
  809.                                             LT_SetAttributes(Handle,GAD_REMOVE,
  810.                                                 GA_Disabled,    TRUE,
  811.                                             TAG_DONE);
  812.  
  813.                                             LT_SetAttributes(Handle,GAD_NAME,
  814.                                                 GTST_String,    "",
  815.                                             TAG_DONE);
  816.  
  817.                                             LT_SetAttributes(Handle,GAD_CLEAR,
  818.                                                 GA_Disabled,    !TransferCount,
  819.                                             TAG_DONE);
  820.  
  821.                                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  822.                                                 GA_Disabled,    !TransferCount,
  823.                                             TAG_DONE);
  824.  
  825.                                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  826.                                                 GA_Disabled,    !TransferCount,
  827.                                             TAG_DONE);
  828.  
  829.                                             LT_SetAttributes(Handle,GAD_LIST,
  830.                                                 GTLV_Labels,    TransferList,
  831.                                             TAG_DONE);
  832.  
  833.                                             LT_UnlockWindow(LocalWindow);
  834.                                         }
  835.  
  836.                                         break;
  837.                                     }
  838.  
  839.                                         // Show or hide the icon?
  840.  
  841.                                     case TRANSFERMSG_TOGGLE_ICON:
  842.  
  843.                                             // Hide the icon
  844.  
  845.                                         if(Item -> Size)
  846.                                         {
  847.                                             if(AppIcon)
  848.                                             {
  849.                                                 RemoveAppIcon(AppIcon);
  850.  
  851.                                                 AppIcon = NULL;
  852.                                             }
  853.  
  854.                                             if(LoadedIcon)
  855.                                             {
  856.                                                 FreeDiskObject(LoadedIcon);
  857.  
  858.                                                 LoadedIcon = NULL;
  859.                                             }
  860.                                         }
  861.                                         else
  862.                                         {
  863.                                             if(!AppIcon)
  864.                                             {
  865.                                                 if(WorkbenchBase)
  866.                                                 {
  867.                                                     if(IconBase)
  868.                                                     {
  869.                                                         UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  870.  
  871.                                                         strcpy(LocalBuffer,Config -> PathConfig -> DefaultStorage);
  872.  
  873.                                                         if(AddPart(LocalBuffer,"term_DropIcon",MAX_FILENAME_LENGTH))
  874.                                                             LoadedIcon = GetDiskObject(LocalBuffer);
  875.  
  876.                                                         if(!LoadedIcon)
  877.                                                             LoadedIcon = GetDiskObject("PROGDIR:term_DropIcon");
  878.                                                     }
  879.  
  880.                                                     AppIcon = AddAppIconA(APP_ICON,NULL,LocaleString(MSG_UPLOADQUEUE_TERM_UPLOAD_LIST_TXT),AppPort,NULL,LoadedIcon ? LoadedIcon : &DropIcon,NULL);
  881.                                                 }
  882.                                                 else
  883.                                                     AppIcon = NULL;
  884.                                             }
  885.                                         }
  886.  
  887.                                         break;
  888.                                 }
  889.  
  890.                                 DeleteMsgItem(Item);
  891.                             }
  892.                         }
  893.  
  894.                         if(Signals & SIG_HIDE)
  895.                         {
  896.                             if(AppWindow)
  897.                             {
  898.                                 RemoveAppWindow(AppWindow);
  899.  
  900.                                 AppWindow = NULL;
  901.                             }
  902.  
  903.                             if(Handle)
  904.                             {
  905.                                 LT_DeleteHandle(Handle);
  906.  
  907.                                 Handle = NULL;
  908.                             }
  909.  
  910.                             WindowMask    = NULL;
  911.                             LocalWindow    = NULL;
  912.  
  913.                             TransferProcess -> pr_WindowPtr = OldPtr;
  914.  
  915.                             Signal(ThisProcess,SIG_HANDSHAKE);
  916.                         }
  917.  
  918.                         if(Signals & SIG_GOAWAY)
  919.                         {
  920.                             if(Handle)
  921.                             {
  922.                                 if(LocalWindow -> WScreen == Screen)
  923.                                 {
  924.                                     if(AppWindow)
  925.                                     {
  926.                                         RemoveAppWindow(AppWindow);
  927.  
  928.                                         AppWindow = NULL;
  929.                                     }
  930.  
  931.                                     LT_DeleteHandle(Handle);
  932.  
  933.                                     Handle        = NULL;
  934.                                     WindowMask    = NULL;
  935.                                     LocalWindow    = NULL;
  936.  
  937.                                     TransferProcess -> pr_WindowPtr = OldPtr;
  938.                                 }
  939.                             }
  940.  
  941.                             Signal(ThisProcess,SIG_HANDSHAKE);
  942.                         }
  943.  
  944.                         if(Signals & SIG_KILL)
  945.                             break;
  946.  
  947.                         if(Signals & SIG_SHOW)
  948.                         {
  949.                             if(!Handle)
  950.                             {
  951.                                 Forbid();
  952.  
  953.                                 if(Handle = QueuePanel(Window))
  954.                                 {
  955.                                     Permit();
  956.  
  957.                                     if(WorkbenchBase)
  958.                                         AppWindow = AddAppWindowA(APP_WINDOW,NULL,Handle -> Window,AppPort,NULL);
  959.                                     else
  960.                                         AppWindow = NULL;
  961.  
  962.                                     LocalWindow    = Handle -> Window;
  963.                                     WindowMask    = PORTMASK(LocalWindow -> UserPort);
  964.  
  965.                                     TransferProcess -> pr_WindowPtr = LocalWindow;
  966.                                 }
  967.                                 else
  968.                                     Permit();
  969.                             }
  970.  
  971.                             if(Handle)
  972.                                 LT_ShowWindow(Handle,TRUE);
  973.                         }
  974.  
  975.                         if(Signals & WindowMask)
  976.                         {
  977.                             struct DataMsg    Msg;
  978.                             LONG        Type;
  979.  
  980.                             switch(Type = HandleQueueWindow(Handle))
  981.                             {
  982.                                 case GAD_HIDE:
  983.  
  984.                                     if(AppWindow)
  985.                                     {
  986.                                         RemoveAppWindow(AppWindow);
  987.  
  988.                                         AppWindow = NULL;
  989.                                     }
  990.  
  991.                                     if(Handle)
  992.                                     {
  993.                                         LT_DeleteHandle(Handle);
  994.  
  995.                                         Handle = NULL;
  996.                                     }
  997.  
  998.                                     TransferProcess -> pr_WindowPtr = OldPtr;
  999.  
  1000.                                     WindowMask    = NULL;
  1001.                                     LocalWindow    = NULL;
  1002.  
  1003.                                     break;
  1004.  
  1005.                                 case UPLOAD_BINARY:
  1006.                                 case UPLOAD_TEXT:
  1007.  
  1008.                                     InitMsgItem(&Msg,QueueClientDestructor);
  1009.  
  1010.                                     Msg . Type = DATAMSGTYPE_UPLOAD;
  1011.                                     Msg . Data = (UBYTE *)TransferList;
  1012.                                     Msg . Size = Type;
  1013.  
  1014.                                     if(Handle)
  1015.                                     {
  1016.                                         LT_SetAttributes(Handle,GAD_LIST,
  1017.                                             GTLV_Labels,    ~0,
  1018.                                         TAG_DONE);
  1019.  
  1020.                                         LT_LockWindow(LocalWindow);
  1021.                                     }
  1022.  
  1023.                                     Forbid();
  1024.  
  1025.                                     ClrSignal(ClientMask);
  1026.  
  1027.                                     PutMsgItem(SpecialQueue,(struct MsgItem *)&Msg);
  1028.  
  1029.                                     Wait(ClientMask);
  1030.  
  1031.                                     Permit();
  1032.  
  1033.                                     if(Handle)
  1034.                                     {
  1035.                                         TransferCount = GetListSize(TransferList);
  1036.  
  1037.                                         TransferOffset    = -1;
  1038.                                         TransferNode    = NULL;
  1039.  
  1040.                                         LT_SetAttributes(Handle,GAD_REMOVE,
  1041.                                             GA_Disabled,    TRUE,
  1042.                                         TAG_DONE);
  1043.  
  1044.                                         LT_SetAttributes(Handle,GAD_NAME,
  1045.                                             GTST_String,    "",
  1046.                                         TAG_DONE);
  1047.  
  1048.                                         LT_SetAttributes(Handle,GAD_CLEAR,
  1049.                                             GA_Disabled,    !TransferCount,
  1050.                                         TAG_DONE);
  1051.  
  1052.                                         LT_SetAttributes(Handle,UPLOAD_BINARY,
  1053.                                             GA_Disabled,    !TransferCount,
  1054.                                         TAG_DONE);
  1055.  
  1056.                                         LT_SetAttributes(Handle,UPLOAD_TEXT,
  1057.                                             GA_Disabled,    !TransferCount,
  1058.                                         TAG_DONE);
  1059.  
  1060.                                         LT_SetAttributes(Handle,GAD_LIST,
  1061.                                             GTLV_Labels,    TransferList,
  1062.                                         TAG_DONE);
  1063.  
  1064.                                         LT_UnlockWindow(LocalWindow);
  1065.                                     }
  1066.  
  1067.                                     break;
  1068.                             }
  1069.                         }
  1070.  
  1071.                         if(Signals & PORTMASK(AppPort))
  1072.                         {
  1073.                             while(AppMessage = (struct AppMessage *)GetMsg(AppPort))
  1074.                             {
  1075.                                 if(AppMessage -> am_Type == AMTYPE_APPWINDOW && Handle)
  1076.                                 {
  1077.                                     UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  1078.                                     BPTR    OldDir,FileLock;
  1079.                                     LONG    i;
  1080.  
  1081.                                     TransferProcess -> pr_WindowPtr = (APTR)-1;
  1082.  
  1083.                                     LT_SetAttributes(Handle,GAD_LIST,
  1084.                                         GTLV_Labels,    ~0,
  1085.                                     TAG_DONE);
  1086.  
  1087.                                     for(i = 0 ; i < AppMessage -> am_NumArgs ; i++)
  1088.                                     {
  1089.                                         if(AppMessage -> am_ArgList[i] . wa_Name)
  1090.                                         {
  1091.                                             OldDir = CurrentDir(AppMessage -> am_ArgList[i] . wa_Lock);
  1092.  
  1093.                                             if(GetFileSize(AppMessage -> am_ArgList[i] . wa_Name))
  1094.                                             {
  1095.                                                 if(FileLock = Lock(AppMessage -> am_ArgList[i] . wa_Name,ACCESS_READ))
  1096.                                                 {
  1097.                                                     if(NameFromLock(FileLock,DummyBuffer,MAX_FILENAME_LENGTH))
  1098.                                                     {
  1099.                                                         struct Node *Node;
  1100.  
  1101.                                                         if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  1102.                                                         {
  1103.                                                             Node -> ln_Name = (STRPTR)(Node + 1);
  1104.  
  1105.                                                             strcpy(Node -> ln_Name,DummyBuffer);
  1106.  
  1107.                                                             AddTail(TransferList,Node);
  1108.  
  1109.                                                             TransferCount++;
  1110.                                                         }
  1111.                                                     }
  1112.  
  1113.                                                     UnLock(FileLock);
  1114.                                                 }
  1115.                                             }
  1116.  
  1117.                                             CurrentDir(OldDir);
  1118.                                         }
  1119.                                     }
  1120.  
  1121.                                     TransferProcess -> pr_WindowPtr = LocalWindow;
  1122.  
  1123.                                     LT_SetAttributes(Handle,GAD_LIST,
  1124.                                         GTLV_Labels,    TransferList,
  1125.                                     TAG_DONE);
  1126.  
  1127.                                     LT_SetAttributes(Handle,GAD_CLEAR,
  1128.                                         GA_Disabled,    !TransferCount,
  1129.                                     TAG_DONE);
  1130.  
  1131.                                     LT_SetAttributes(Handle,UPLOAD_BINARY,
  1132.                                         GA_Disabled,    !TransferCount,
  1133.                                     TAG_DONE);
  1134.  
  1135.                                     LT_SetAttributes(Handle,UPLOAD_TEXT,
  1136.                                         GA_Disabled,    !TransferCount,
  1137.                                     TAG_DONE);
  1138.                                 }
  1139.  
  1140.                                 if(AppMessage -> am_Type == AMTYPE_APPICON)
  1141.                                 {
  1142.                                     if(AppMessage -> am_NumArgs)
  1143.                                     {
  1144.                                         UBYTE    DummyBuffer[MAX_FILENAME_LENGTH];
  1145.                                         BPTR    OldDir,FileLock;
  1146.                                         LONG    i;
  1147.  
  1148.                                         TransferProcess -> pr_WindowPtr = (APTR)-1;
  1149.  
  1150.                                         if(Handle)
  1151.                                         {
  1152.                                             LT_SetAttributes(Handle,GAD_LIST,
  1153.                                                 GTLV_Labels,    ~0,
  1154.                                             TAG_DONE);
  1155.                                         }
  1156.  
  1157.                                         for(i = 0 ; i < AppMessage -> am_NumArgs ; i++)
  1158.                                         {
  1159.                                             if(AppMessage -> am_ArgList[i] . wa_Name)
  1160.                                             {
  1161.                                                 OldDir = CurrentDir(AppMessage -> am_ArgList[i] . wa_Lock);
  1162.  
  1163.                                                 if(GetFileSize(AppMessage -> am_ArgList[i] . wa_Name))
  1164.                                                 {
  1165.                                                     if(FileLock = Lock(AppMessage -> am_ArgList[i] . wa_Name,ACCESS_READ))
  1166.                                                     {
  1167.                                                         if(NameFromLock(FileLock,DummyBuffer,MAX_FILENAME_LENGTH))
  1168.                                                         {
  1169.                                                             struct Node *Node;
  1170.  
  1171.                                                             if(Node = (struct Node *)AllocVecPooled(sizeof(struct Node) + 256,MEMF_ANY))
  1172.                                                             {
  1173.                                                                 Node -> ln_Name = (STRPTR)(Node + 1);
  1174.  
  1175.                                                                 strcpy(Node -> ln_Name,DummyBuffer);
  1176.  
  1177.                                                                 AddTail(TransferList,Node);
  1178.  
  1179.                                                                 TransferCount++;
  1180.                                                             }
  1181.                                                         }
  1182.  
  1183.                                                         UnLock(FileLock);
  1184.                                                     }
  1185.                                                 }
  1186.  
  1187.                                                 CurrentDir(OldDir);
  1188.                                             }
  1189.                                         }
  1190.  
  1191.                                         if(Handle)
  1192.                                         {
  1193.                                             TransferProcess -> pr_WindowPtr = LocalWindow;
  1194.  
  1195.                                             LT_SetAttributes(Handle,GAD_LIST,
  1196.                                                 GTLV_Labels,    TransferList,
  1197.                                             TAG_DONE);
  1198.  
  1199.                                             LT_SetAttributes(Handle,GAD_CLEAR,
  1200.                                                 GA_Disabled,    !TransferCount,
  1201.                                             TAG_DONE);
  1202.  
  1203.                                             LT_SetAttributes(Handle,UPLOAD_BINARY,
  1204.                                                 GA_Disabled,    !TransferCount,
  1205.                                             TAG_DONE);
  1206.  
  1207.                                             LT_SetAttributes(Handle,UPLOAD_TEXT,
  1208.                                                 GA_Disabled,    !TransferCount,
  1209.                                             TAG_DONE);
  1210.                                         }
  1211.                                         else
  1212.                                             TransferProcess -> pr_WindowPtr = OldPtr;
  1213.                                     }
  1214.                                     else
  1215.                                     {
  1216.                                         if(!Handle)
  1217.                                         {
  1218.                                             if(Handle = QueuePanel(NULL))
  1219.                                             {
  1220.                                                 AppWindow = AddAppWindowA(APP_WINDOW,NULL,Handle -> Window,AppPort,NULL);
  1221.  
  1222.                                                 LocalWindow = Handle -> Window;
  1223.  
  1224.                                                 WindowMask = PORTMASK(LocalWindow -> UserPort);
  1225.  
  1226.                                                 TransferProcess -> pr_WindowPtr = LocalWindow;
  1227.                                             }
  1228.                                         }
  1229.                                     }
  1230.                                 }
  1231.  
  1232.                                 ReplyMsg(AppMessage);
  1233.                             }
  1234.                         }
  1235.                     }
  1236.                     while(!Done);
  1237.  
  1238.                     if(AppIcon)
  1239.                         RemoveAppIcon(AppIcon);
  1240.  
  1241.                     if(AppWindow)
  1242.                         RemoveAppWindow(AppWindow);
  1243.  
  1244.                     if(LoadedIcon)
  1245.                         FreeDiskObject(LoadedIcon);
  1246.  
  1247.                     if(Handle)
  1248.                         LT_DeleteHandle(Handle);
  1249.  
  1250.                     while(AppMessage = (struct AppMessage *)GetMsg(AppPort))
  1251.                         ReplyMsg(AppMessage);
  1252.  
  1253.                     FreeSignal(TransferSignal);
  1254.                 }
  1255.             }
  1256.  
  1257.             DeleteMsgQueue(TransferQueue);
  1258.         }
  1259.  
  1260.         DeleteList(TransferList);
  1261.  
  1262.         TransferList = NULL;
  1263.     }
  1264.  
  1265.     Forbid();
  1266.  
  1267.     TransferProcess = NULL;
  1268.  
  1269.     Signal(ThisProcess,SIG_HANDSHAKE);
  1270. }
  1271.  
  1272.     /* CloseQueueWindow():
  1273.      *
  1274.      *    Close the queue window, wherever it may be.
  1275.      */
  1276.  
  1277. VOID
  1278. CloseQueueWindow()
  1279. {
  1280.     if(TransferProcess)
  1281.     {
  1282.         Forbid();
  1283.  
  1284.         ClrSignal(SIG_HANDSHAKE);
  1285.  
  1286.         Signal(TransferProcess,SIG_GOAWAY);
  1287.  
  1288.         Wait(SIG_HANDSHAKE);
  1289.  
  1290.         Permit();
  1291.     }
  1292. }
  1293.  
  1294.     /* DeleteQueueProcess():
  1295.      *
  1296.      *    Terminate the queue handler process.
  1297.      */
  1298.  
  1299. VOID
  1300. DeleteQueueProcess()
  1301. {
  1302.     if(TransferProcess)
  1303.     {
  1304.         Forbid();
  1305.  
  1306.         ClrSignal(SIG_HANDSHAKE);
  1307.  
  1308.         Signal(TransferProcess,SIG_KILL);
  1309.  
  1310.         Wait(SIG_HANDSHAKE);
  1311.  
  1312.         Permit();
  1313.     }
  1314. }
  1315.  
  1316.     /* CreateQueueProcess():
  1317.      *
  1318.      *    Create the queue handler process, if it's still around
  1319.      *    bring it to the front.
  1320.      */
  1321.  
  1322. BOOL
  1323. CreateQueueProcess()
  1324. {
  1325.     if(!TransferProcess)
  1326.     {
  1327.         BPTR UploadDrawer = Lock(Config->PathConfig->BinaryUploadPath,SHARED_LOCK);
  1328.  
  1329.         Forbid();
  1330.  
  1331.         if(CreateNewProcTags(
  1332.             NP_Entry,    QueueEntry,
  1333.             NP_Name,    "term Upload process",
  1334.             NP_WindowPtr,    NULL,
  1335.             NP_CurrentDir,    UploadDrawer,
  1336.         TAG_DONE))
  1337.         {
  1338.             ClrSignal(SIG_HANDSHAKE);
  1339.  
  1340.             Wait(SIG_HANDSHAKE);
  1341.         }
  1342.  
  1343.         Permit();
  1344.  
  1345.         if(!TransferProcess)
  1346.             UnLock(UploadDrawer);
  1347.     }
  1348.     else
  1349.         Signal(TransferProcess,SIG_SHOW);
  1350.  
  1351.     return((BOOL)(TransferProcess != NULL));
  1352. }
  1353.  
  1354. STATIC VOID __stdargs
  1355. LocalMsgDestructor(struct DataMsg *Item)
  1356. {
  1357.     Signal(Item -> Client,Item -> Mask);
  1358. }
  1359.  
  1360.     /* GetUploadList():
  1361.      *
  1362.      *    Copy the current upload list and return it.
  1363.      */
  1364.  
  1365. struct List *
  1366. GetUploadList()
  1367. {
  1368.     if(TransferProcess)
  1369.     {
  1370.         LONG SigBit;
  1371.  
  1372.         if((SigBit = AllocSignal(-1)) != -1)
  1373.         {
  1374.             struct DataMsg Msg;
  1375.  
  1376.             InitMsgItem(&Msg,LocalMsgDestructor);
  1377.  
  1378.             Msg . Type    = TRANSFERMSG_GET_LIST;
  1379.             Msg . Client    = FindTask(NULL);
  1380.             Msg . Mask    = 1L << SigBit;
  1381.  
  1382.             ClrSignal(Msg . Mask);
  1383.  
  1384.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  1385.  
  1386.             Wait(Msg . Mask);
  1387.  
  1388.             FreeSignal(SigBit);
  1389.  
  1390.             return((struct List *)Msg . Data);
  1391.         }
  1392.     }
  1393.  
  1394.     return(NULL);
  1395. }
  1396.  
  1397.     /* CheckUpload():
  1398.      *
  1399.      *    Check if there is anything in the upload list.
  1400.      */
  1401.  
  1402. BOOL
  1403. CheckUpload()
  1404. {
  1405.     if(TransferProcess)
  1406.     {
  1407.         LONG SigBit;
  1408.  
  1409.         if((SigBit = AllocSignal(-1)) != -1)
  1410.         {
  1411.             struct DataMsg Msg;
  1412.  
  1413.             InitMsgItem(&Msg,LocalMsgDestructor);
  1414.  
  1415.             Msg . Type    = TRANSFERMSG_CHECK_LIST;
  1416.             Msg . Client    = FindTask(NULL);
  1417.             Msg . Mask    = 1L << SigBit;
  1418.  
  1419.             ClrSignal(Msg . Mask);
  1420.  
  1421.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  1422.  
  1423.             Wait(Msg . Mask);
  1424.  
  1425.             FreeSignal(SigBit);
  1426.  
  1427.             return((BOOL)Msg . Size);
  1428.         }
  1429.     }
  1430.  
  1431.     return(FALSE);
  1432. }
  1433.  
  1434.     /* StartUpload(UBYTE Type):
  1435.      *
  1436.      *    Start an upload the standard way.
  1437.      */
  1438.  
  1439. VOID
  1440. StartUpload(UBYTE Type)
  1441. {
  1442.     if(TransferProcess)
  1443.     {
  1444.         LONG SigBit;
  1445.  
  1446.         if((SigBit = AllocSignal(-1)) != -1)
  1447.         {
  1448.             struct DataMsg Msg;
  1449.  
  1450.             SetQueueDiscard(SpecialQueue,FALSE);
  1451.  
  1452.             InitMsgItem(&Msg,LocalMsgDestructor);
  1453.  
  1454.             Msg . Type    = TRANSFERMSG_UPLOAD;
  1455.             Msg . Size    = Type;
  1456.             Msg . Client    = FindTask(NULL);
  1457.             Msg . Mask    = 1L << SigBit;
  1458.  
  1459.             ClrSignal(Msg . Mask);
  1460.  
  1461.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  1462.  
  1463.             Wait(Msg . Mask);
  1464.  
  1465.             FreeSignal(SigBit);
  1466.         }
  1467.     }
  1468. }
  1469.  
  1470.     /* ToggleUploadQueueIcon():
  1471.      *
  1472.      *    Turn the upload queue appicon on or off.
  1473.      */
  1474.  
  1475. VOID
  1476. ToggleUploadQueueIcon(BOOL Mode)
  1477. {
  1478.     if(TransferProcess)
  1479.     {
  1480.         LONG SigBit;
  1481.  
  1482.         if((SigBit = AllocSignal(-1)) != -1)
  1483.         {
  1484.             struct DataMsg Msg;
  1485.  
  1486.             InitMsgItem(&Msg,LocalMsgDestructor);
  1487.  
  1488.             Msg . Type    = TRANSFERMSG_TOGGLE_ICON;
  1489.             Msg . Size    = Mode;
  1490.             Msg . Client    = FindTask(NULL);
  1491.             Msg . Mask    = 1L << SigBit;
  1492.  
  1493.             ClrSignal(Msg . Mask);
  1494.  
  1495.             PutMsgItem(TransferQueue,(struct MsgItem *)&Msg);
  1496.  
  1497.             Wait(Msg . Mask);
  1498.  
  1499.             FreeSignal(SigBit);
  1500.         }
  1501.     }
  1502. }
  1503.